#!/usr/bin/env node

/**
 * 数据库导出工具 - 导出数据到 Excel
 * 
 * 用法：
 *   node export-to-excel.js                              # 导出所有数据
 *   node export-to-excel.js --keyword "Baby Foods"       # 导出特定关键字
 *   node export-to-excel.js --limit 100                  # 限制导出数量
 *   node export-to-excel.js --date 2025-10-18           # 导出特定日期
 *   node export-to-excel.js --rating 4.5                 # 只导出高评分商品
 */

const XLSX = require('xlsx');
const fs = require('fs');
const path = require('path');
const dbConnection = require('./db/connection');
const CrawlResult = require('./db/models/CrawlResult');
const config = require('./tasks.config');

// 解析命令行参数
function parseArgs() {
    const args = process.argv.slice(2);
    const options = {
        keyword: null,           // 搜索关键字
        task: '亚马逊德国',      // 任务名称
        limit: null,             // 限制数量
        date: null,              // 日期过滤 (YYYY-MM-DD)
        after: null,             // 导出此时间之后的数据 (YYYY-MM-DD HH:mm)
        before: null,            // 导出此时间之前的数据 (YYYY-MM-DD HH:mm)
        rating: null,            // 最低评分
        hasPrice: false,         // 只导出有价格的
        hasSales: false,         // 只导出有销量的
        output: null,            // 输出文件名
        format: 'detailed',      // 导出格式：detailed | simple | custom
    };

    for (let i = 0; i < args.length; i++) {
        const arg = args[i];

        if (arg === '--keyword' || arg === '-k') {
            options.keyword = args[++i];
        } else if (arg === '--task' || arg === '-t') {
            options.task = args[++i];
        } else if (arg === '--limit' || arg === '-l') {
            options.limit = parseInt(args[++i]);
        } else if (arg === '--date' || arg === '-d') {
            options.date = args[++i];
        } else if (arg === '--after' || arg === '-a') {
            options.after = args[++i];
        } else if (arg === '--before' || arg === '-b') {
            options.before = args[++i];
        } else if (arg === '--rating' || arg === '-r') {
            options.rating = parseFloat(args[++i]);
        } else if (arg === '--has-price') {
            options.hasPrice = true;
        } else if (arg === '--has-sales') {
            options.hasSales = true;
        } else if (arg === '--output' || arg === '-o') {
            options.output = args[++i];
        } else if (arg === '--format' || arg === '-f') {
            options.format = args[++i];
        } else if (arg === '--simple') {
            options.format = 'simple';
        } else if (arg === '--help' || arg === '-h') {
            printHelp();
            process.exit(0);
        }
    }

    return options;
}

// 打印帮助信息
function printHelp() {
    console.log(`
数据库导出工具 - 导出数据到 Excel

用法：
  node export-to-excel.js [选项]

选项：
  -k, --keyword <关键字>     按搜索关键字过滤
  -t, --task <任务名>        按任务名称过滤（默认：亚马逊德国）
  -l, --limit <数量>         限制导出数量
  -d, --date <日期>          导出特定日期的数据 (YYYY-MM-DD)
  -a, --after <时间>         导出此时间之后的数据 (YYYY-MM-DD HH:mm)
  -b, --before <时间>        导出此时间之前的数据 (YYYY-MM-DD HH:mm)
  -r, --rating <评分>        只导出评分 >= 指定值的商品
  --has-price                只导出有价格信息的商品
  --has-sales                只导出有销量信息的商品
  -o, --output <文件名>      指定输出文件名
  -f, --format <格式>        导出格式：detailed | simple | custom
  --simple                   简化格式（等同于 --format simple）
  -h, --help                 显示帮助信息

示例：
  # 导出所有数据
  node export-to-excel.js

  # 导出特定关键字的数据
  node export-to-excel.js --keyword "Baby Foods"

  # 导出高评分商品（4.5星以上）
  node export-to-excel.js --rating 4.5 --limit 50

  # 导出特定日期的数据
  node export-to-excel.js --date 2025-10-18

  # 导出2025年10月18日12:00之后的数据
  node export-to-excel.js --after "2025-10-18 12:00"

  # 导出时间范围内的数据
  node export-to-excel.js --after "2025-10-18 12:00" --before "2025-10-18 18:00"

  # 导出有价格和销量的商品
  node export-to-excel.js --has-price --has-sales

  # 简化格式导出
  node export-to-excel.js --simple --keyword "Baby Foods"
    `);
}

// 构建查询条件
function buildQuery(options) {
    const query = {
        taskName: options.task,
        success: true
    };

    // 按关键字过滤
    if (options.keyword) {
        query.searchKeyword = options.keyword;
    }

    // 按日期过滤
    if (options.date) {
        const startDate = new Date(options.date);
        const endDate = new Date(options.date);
        endDate.setDate(endDate.getDate() + 1);
        
        query.crawlTimestamp = {
            $gte: startDate,
            $lt: endDate
        };
    }

    // 按时间范围过滤（优先级高于 date）
    if (options.after || options.before) {
        query.crawlTimestamp = query.crawlTimestamp || {};
        
        if (options.after) {
            // 支持 "YYYY-MM-DD HH:mm" 或 "YYYY-MM-DD HH:mm:ss" 格式
            const afterDate = new Date(options.after);
            if (!isNaN(afterDate.getTime())) {
                query.crawlTimestamp.$gte = afterDate;
            } else {
                console.warn(`⚠️  警告：无效的 after 时间格式: ${options.after}`);
            }
        }
        
        if (options.before) {
            const beforeDate = new Date(options.before);
            if (!isNaN(beforeDate.getTime())) {
                query.crawlTimestamp.$lt = beforeDate;
            } else {
                console.warn(`⚠️  警告：无效的 before 时间格式: ${options.before}`);
            }
        }
    }

    // 按评分过滤
    if (options.rating) {
        query['data.rating.rating'] = { $gte: options.rating };
    }

    // 只导出有价格的
    if (options.hasPrice) {
        query['data.price'] = { $exists: true, $ne: null };
    }

    // 只导出有销量的
    if (options.hasSales) {
        query['data.sales'] = { $exists: true, $ne: null };
    }

    return query;
}

// 转换数据为详细格式
function formatDataDetailed(results) {
    return results.map(result => {
        const data = result.data || {};
        const price = data.price || {};
        const rating = data.rating || {};
        const sales = data.sales || {};

        return {
            // 基本信息
            '任务名称': result.taskName,
            '搜索关键字': result.searchKeyword || 'N/A',
            '商品标题': data.title || 'N/A',
            'ASIN': data.asin || 'N/A',
            '商品URL': data.url || 'N/A',
            
            // 价格信息
            '币种': price.currency || 'N/A',
            '当前价格': price.value || 'N/A',
            '原价': price.rrpValue || 'N/A',
            '折扣': price.discount || 'N/A',
            '节省金额': price.savings || 'N/A',
            
            // 评分信息
            '评分': rating.rating || 'N/A',
            '评论数': rating.reviewCount || 'N/A',
            
            // 销量信息
            '销量': sales.fullText || 'N/A',
            '销量数值': sales.count || 'N/A',
            '销量周期': sales.period || 'N/A',
            
            // 其他信息
            // '爬取时间': result.crawlTimestamp ? new Date(result.crawlTimestamp).toLocaleString('zh-CN') : 'N/A',
            '数据库ID': result._id.toString()
        };
    });
}

// 转换数据为简化格式
function formatDataSimple(results) {
    return results.map(result => {
        const data = result.data || {};
        const price = data.price || {};
        const rating = data.rating || {};

        return {
            '关键字': result.searchKeyword || 'N/A',
            '标题': data.title || 'N/A',
            'ASIN': data.asin || 'N/A',
            '价格': price.value || 'N/A',
            '评分': rating.rating || 'N/A',
            '评论数': rating.reviewCount || 'N/A',
            '链接': data.url || 'N/A'
        };
    });
}

// 生成输出文件名
function generateFileName(options) {
    if (options.output) {
        return options.output.endsWith('.xlsx') ? options.output : `${options.output}.xlsx`;
    }

    const timestamp = new Date().toISOString().replace(/[:.]/g, '-').split('T')[0];
    const parts = ['export', options.task];
    
    if (options.keyword) {
        parts.push(options.keyword.replace(/\s+/g, '_'));
    }
    
    if (options.date) {
        parts.push(options.date);
    }
    
    parts.push(timestamp);
    
    return parts.join('_') + '.xlsx';
}

// 主函数
async function main() {
    console.log('========================================');
    console.log('    数据库导出工具 - Excel 导出');
    console.log('========================================\n');

    const options = parseArgs();

    try {
        // 连接数据库
        console.log('📊 正在连接数据库...');
        await dbConnection.connect();
        console.log('✅ 数据库连接成功\n');

        // 构建查询
        const query = buildQuery(options);
        console.log('🔍 查询条件:');
        console.log(JSON.stringify(query, null, 2));
        console.log('');

        // 执行查询
        console.log('📥 正在查询数据...');
        let queryBuilder = CrawlResult.find(query).sort({ crawlTimestamp: -1 });
        
        if (options.limit) {
            queryBuilder = queryBuilder.limit(options.limit);
        }
        
        const results = await queryBuilder.lean();
        console.log(`✅ 查询完成，找到 ${results.length} 条记录\n`);

        if (results.length === 0) {
            console.log('⚠️  没有找到符合条件的数据');
            return;
        }

        // 转换数据格式
        console.log('🔄 正在转换数据格式...');
        let formattedData;
        
        if (options.format === 'simple') {
            formattedData = formatDataSimple(results);
            console.log('📋 使用简化格式');
        } else {
            formattedData = formatDataDetailed(results);
            console.log('📋 使用详细格式');
        }

        // 创建工作簿
        console.log('📝 正在创建 Excel 文件...');
        const worksheet = XLSX.utils.json_to_sheet(formattedData);
        const workbook = XLSX.utils.book_new();
        XLSX.utils.book_append_sheet(workbook, worksheet, '商品数据');

        // 设置列宽
        const columnWidths = Object.keys(formattedData[0] || {}).map(key => {
            if (key.includes('URL') || key.includes('链接')) return { wch: 50 };
            if (key.includes('标题')) return { wch: 40 };
            if (key.includes('关键字')) return { wch: 20 };
            if (key.includes('ASIN')) return { wch: 15 };
            return { wch: 12 };
        });
        worksheet['!cols'] = columnWidths;

        // 保存文件
        const exportsDir = path.join(__dirname, 'exports');
        if (!fs.existsSync(exportsDir)) {
            fs.mkdirSync(exportsDir, { recursive: true });
        }

        const fileName = generateFileName(options);
        const filePath = path.join(exportsDir, fileName);
        
        XLSX.writeFile(workbook, filePath);
        console.log('✅ Excel 文件创建成功\n');

        // 打印统计信息
        console.log('========================================');
        console.log('📊 导出统计');
        console.log('========================================');
        console.log(`导出记录数: ${results.length}`);
        console.log(`输出文件:   ${fileName}`);
        console.log(`文件路径:   ${filePath}`);
        console.log(`文件大小:   ${(fs.statSync(filePath).size / 1024).toFixed(2)} KB`);
        console.log('========================================\n');

        // 打印数据预览
        if (results.length > 0) {
            console.log('📋 数据预览（前3条）:\n');
            const preview = formattedData.slice(0, 3);
            preview.forEach((item, index) => {
                console.log(`${index + 1}. ${item['商品标题'] || item['标题']}`);
                if (item['搜索关键字']) console.log(`   关键字: ${item['搜索关键字']}`);
                if (item['当前价格'] || item['价格']) {
                    console.log(`   价格: ${item['当前价格'] || item['价格']}`);
                }
                if (item['评分']) console.log(`   评分: ${item['评分']}`);
                console.log('');
            });
        }

        console.log('🎉 导出完成！');

    } catch (error) {
        console.error('❌ 导出失败:', error.message);
        console.error(error.stack);
        process.exit(1);
    } finally {
        // 断开数据库连接
        await dbConnection.disconnect();
    }
}

// 运行
if (require.main === module) {
    main().catch(error => {
        console.error('❌ 执行过程中出现致命错误:', error);
        process.exit(1);
    });
}

module.exports = main;

